{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bayesian Regression - Introduction (Part 1)\n",
    "\n",
    "Regression is one of the most common and basic supervised learning tasks in machine learning. Suppose we're given a dataset $\\mathcal{D}$ of the form\n",
    "\n",
    "$$ \\mathcal{D}  = \\{ (X_i, y_i) \\} \\qquad \\text{for}\\qquad i=1,2,...,N$$\n",
    "\n",
    "The goal of linear regression is to fit a function to the data of the form:\n",
    "\n",
    "$$ y = w X + b + \\epsilon $$\n",
    "\n",
    "where $w$ and $b$ are learnable parameters and $\\epsilon$ represents observation noise. Specifically $w$ is a matrix of weights and $b$ is a bias vector.\n",
    "\n",
    "Let's first implement linear regression in PyTorch and learn point estimates for the parameters $w$ and $b$.  Then we'll see how to incorporate uncertainty into our estimates by using Pyro to implement Bayesian regression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "Let's begin by importing the modules we'll need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from functools import partial\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import pyro\n",
    "from pyro.distributions import Normal, Uniform, Delta\n",
    "from pyro.infer import SVI, Trace_ELBO\n",
    "from pyro.optim import Adam\n",
    "from pyro.distributions.util import logsumexp\n",
    "from pyro.infer import EmpiricalMarginal, SVI, Trace_ELBO, TracePredictive\n",
    "from pyro.infer.mcmc import MCMC, NUTS\n",
    "import pyro.optim as optim\n",
    "import pyro.poutine as poutine\n",
    "\n",
    "# for CI testing\n",
    "smoke_test = ('CI' in os.environ)\n",
    "assert pyro.__version__.startswith('0.3.0')\n",
    "pyro.enable_validation(True)\n",
    "pyro.set_rng_seed(1)\n",
    "pyro.enable_validation(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset \n",
    "\n",
    "The following example is adapted from \\[1\\].  We would like to explore the relationship between topographic heterogeneity of a nation as measured by the Terrain Ruggedness Index (variable *rugged* in the dataset) and its GDP per capita. In particular, it was noted by the authors in \\[1\\] that terrain ruggedness or bad geography is related to poorer economic performance outside of Africa, but rugged terrains have had a reverse effect on income for African nations. Let us look at the data \\[2\\] and investigate this relationship.  We will be focusing on three features from the dataset:\n",
    "  - `rugged`: quantifies the Terrain Ruggedness Index\n",
    "  - `cont_africa`: whether the given nation is in Africa\n",
    "  - `rgdppc_2000`: Real GDP per capita for the year 2000\n",
    "  \n",
    "We will take the logarithm for the response variable GDP as it tends to vary exponentially."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_URL = \"https://d2fefpcigoriu7.cloudfront.net/datasets/rugged_data.csv\"\n",
    "data = pd.read_csv(DATA_URL, encoding=\"ISO-8859-1\")\n",
    "df = data[[\"cont_africa\", \"rugged\", \"rgdppc_2000\"]]\n",
    "df = df[np.isfinite(df.rgdppc_2000)]\n",
    "df[\"rgdppc_2000\"] = np.log(df[\"rgdppc_2000\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'log GDP (2000)'),\n",
       " Text(0.5, 0, 'Terrain Ruggedness Index'),\n",
       " Text(0.5, 1.0, 'African Nations')]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6), sharey=True)\n",
    "african_nations = data[data[\"cont_africa\"] == 1]\n",
    "non_african_nations = data[data[\"cont_africa\"] == 0]\n",
    "sns.scatterplot(non_african_nations[\"rugged\"], \n",
    "            np.log(non_african_nations[\"rgdppc_2000\"]), \n",
    "            ax=ax[0])\n",
    "ax[0].set(xlabel=\"Terrain Ruggedness Index\",\n",
    "          ylabel=\"log GDP (2000)\",\n",
    "          title=\"Non African Nations\")\n",
    "sns.scatterplot(african_nations[\"rugged\"], \n",
    "            np.log(african_nations[\"rgdppc_2000\"]), \n",
    "            ax=ax[1])\n",
    "ax[1].set(xlabel=\"Terrain Ruggedness Index\",\n",
    "          ylabel=\"log GDP (2000)\",\n",
    "          title=\"African Nations\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Regression\n",
    "We would like to predict log GDP per capita of a nation as a function of two features from the dataset - whether the nation is in Africa, and its Terrain Ruggedness Index.  Let's define our regression model. We'll use PyTorch's `nn.Module` for this.  Our input $X$ is a matrix of size $N \\times 2$ and our output $y$ is a vector of size $2 \\times 1$.  The function `nn.Linear(p, 1)` defines a linear transformation of the form $Xw + b$ where $w$ is the weight matrix and $b$ is the additive bias.  We include an extra `self.factor` term meant to capture the correlation between ruggedness and whether a country is in Africa.\n",
    "\n",
    "Note that we can easily make this a logistic regression by adding a non-linearity in the `forward()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RegressionModel(nn.Module):\n",
    "    def __init__(self, p):\n",
    "        # p = number of features\n",
    "        super(RegressionModel, self).__init__()\n",
    "        self.linear = nn.Linear(p, 1)\n",
    "        self.factor = nn.Parameter(torch.tensor(1.))\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.linear(x) + (self.factor * x[:, 0] * x[:, 1]).unsqueeze(1)\n",
    "\n",
    "p = 2  # number of features\n",
    "regression_model = RegressionModel(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "We will use the mean squared error (MSE) as our loss and Adam as our optimizer. We would like to optimize the parameters of the `regression_model` neural net above. We will use a somewhat large learning rate of `0.05` and run for 500 iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[iteration 0050] loss: 3723.7849\n",
      "[iteration 0100] loss: 1777.9851\n",
      "[iteration 0150] loss: 1226.7543\n",
      "[iteration 0200] loss: 927.1514\n",
      "[iteration 0250] loss: 706.6473\n",
      "[iteration 0300] loss: 536.0911\n",
      "[iteration 0350] loss: 408.0940\n",
      "[iteration 0400] loss: 316.1810\n",
      "[iteration 0450] loss: 252.9711\n",
      "[iteration 0500] loss: 211.2545\n",
      "[iteration 0550] loss: 184.7950\n",
      "[iteration 0600] loss: 168.6502\n",
      "[iteration 0650] loss: 159.1673\n",
      "[iteration 0700] loss: 153.8036\n",
      "[iteration 0750] loss: 150.8815\n",
      "[iteration 0800] loss: 149.3482\n",
      "[iteration 0850] loss: 148.5732\n",
      "[iteration 0900] loss: 148.1960\n",
      "[iteration 0950] loss: 148.0193\n",
      "[iteration 1000] loss: 147.9397\n",
      "Learned parameters:\n",
      "factor 0.37248382\n",
      "linear.weight [[-1.90511    -0.18619268]]\n",
      "linear.bias [9.188872]\n"
     ]
    }
   ],
   "source": [
    "loss_fn = torch.nn.MSELoss(reduction='sum')\n",
    "optim = torch.optim.Adam(regression_model.parameters(), lr=0.05)\n",
    "num_iterations = 1000 if not smoke_test else 2\n",
    "data = torch.tensor(df.values, dtype=torch.float)\n",
    "x_data, y_data = data[:, :-1], data[:, -1]\n",
    "\n",
    "def main():\n",
    "    x_data = data[:, :-1]\n",
    "    y_data = data[:, -1]\n",
    "    for j in range(num_iterations):\n",
    "        # run the model forward on the data\n",
    "        y_pred = regression_model(x_data).squeeze(-1)\n",
    "        # calculate the mse loss\n",
    "        loss = loss_fn(y_pred, y_data)\n",
    "        # initialize gradients to zero\n",
    "        optim.zero_grad()\n",
    "        # backpropagate\n",
    "        loss.backward()\n",
    "        # take a gradient step\n",
    "        optim.step()\n",
    "        if (j + 1) % 50 == 0:\n",
    "            print(\"[iteration %04d] loss: %.4f\" % (j + 1, loss.item()))\n",
    "    # Inspect learned parameters\n",
    "    print(\"Learned parameters:\")\n",
    "    for name, param in regression_model.named_parameters():\n",
    "        print(name, param.data.numpy())\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "[Bayesian modeling](http://mlg.eng.cam.ac.uk/zoubin/papers/NatureReprint15.pdf) offers a systematic framework for reasoning about model uncertainty. Instead of just learning point estimates, we're going to learn a _distribution_ over variables that are consistent with the observed data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian Regression\n",
    "\n",
    "In order to make our linear regression Bayesian, we need to put priors on the parameters $w$ and $b$. These are distributions that represent our prior belief about reasonable values for $w$ and $b$ (before observing any data).\n",
    "\n",
    "### `random_module()`\n",
    "\n",
    "In order to do this, we'll 'lift' the parameters of our existing model to random variables. We can do this in Pyro via `random_module()`, which effectively takes a given `nn.Module` and turns it into a distribution over the same module; in our case, this will be a distribution over regressors. Specifically, each parameter in the original regression model is sampled from the provided prior. This allows us to repurpose vanilla regression models for use in the Bayesian setting. For example:\n",
    "```python\n",
    "loc = torch.zeros(1, 1)\n",
    "scale = torch.ones(1, 1)\n",
    "# define a unit normal prior\n",
    "prior = Normal(loc, scale)\n",
    "# overload the parameters in the regression module with samples from the prior\n",
    "lifted_module = pyro.random_module(\"regression_module\", nn, prior)\n",
    "# sample a nn from the prior\n",
    "sampled_reg_model = lifted_module()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model\n",
    "\n",
    "We now have all the ingredients needed to specify our model. First we define priors over weights, biases, and `factor`. Note the priors that we are using for the different latent variables in the model. The prior on the intercept parameter is very flat as we would like this to be learnt from the data. We are using a weakly regularizing prior on the regression coefficients to avoid overfitting to the data.\n",
    "\n",
    "We wrap `regression_model` with `random_module` and sample an instance of the regressor, `lifted_reg_model`. We then run the regressor on `x_data`. Finally we use the `obs` argument to the `pyro.sample` statement to condition on the observed data `y_data` with a learned observation noise `sigma`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(x_data, y_data):\n",
    "    # weight and bias priors\n",
    "    w_prior = Normal(torch.zeros(1, 2), torch.ones(1, 2)).to_event(1)\n",
    "    b_prior = Normal(torch.tensor([[8.]]), torch.tensor([[1000.]])).to_event(1)\n",
    "    f_prior = Normal(0., 1.)\n",
    "    priors = {'linear.weight': w_prior, 'linear.bias': b_prior, 'factor': f_prior}\n",
    "    scale = pyro.sample(\"sigma\", Uniform(0., 10.))\n",
    "    # lift module parameters to random variables sampled from the priors\n",
    "    lifted_module = pyro.random_module(\"module\", regression_model, priors)\n",
    "    # sample a nn (which also samples w and b)\n",
    "    lifted_reg_model = lifted_module()\n",
    "    with pyro.plate(\"map\", len(x_data)):\n",
    "        # run the nn forward on data\n",
    "        prediction_mean = lifted_reg_model(x_data).squeeze(-1)\n",
    "        # condition on the observed data\n",
    "        pyro.sample(\"obs\",\n",
    "                    Normal(prediction_mean, scale),\n",
    "                    obs=y_data)\n",
    "        return prediction_mean"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Guide\n",
    "\n",
    "In order to do inference we're going to need a guide, i.e. a variational family of distributions.  We will use Pyro's [autoguide library](http://docs.pyro.ai/en/dev/contrib.autoguide.html) to automatically place Gaussians with diagonal covariance on all of the distributions in the model.  Under the hood, this defines a `guide` function with `Normal` distributions with learnable parameters corresponding to each `sample()` in the model.  Autoguide also supports learning MAP estimates with `AutoDelta` or composing guides with `AutoGuideList` (see the [docs](http://docs.pyro.ai/en/dev/contrib.autoguide.html) for more information).   In [Part II](bayesian_regresion_ii.ipynb) we will explore how to write guides by hand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyro.contrib.autoguide import AutoDiagonalNormal\n",
    "guide = AutoDiagonalNormal(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference\n",
    "\n",
    "To do inference we'll use stochastic variational inference (SVI) (for an introduction to SVI, see [SVI Part I](svi_part_i.ipynb)). Just like in the non-Bayesian linear regression, each iteration of our training loop will take a gradient step, with the difference that in this case, we'll use the ELBO objective instead of the MSE loss by constructing a `Trace_ELBO` object that we pass to `SVI`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "optim = Adam({\"lr\": 0.03})\n",
    "svi = SVI(model, guide, optim, loss=Trace_ELBO(), num_samples=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here `Adam` is a thin wrapper around `torch.optim.Adam` (see [here](svi_part_i.ipynb#Optimizers) for a discussion). To take an ELBO gradient step we simply call the step method of SVI. Notice that the data argument we pass to step will be passed to both model() and guide().  The complete training loop is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[iteration 0001] loss: 18.3907\n",
      "[iteration 0101] loss: 3.1146\n",
      "[iteration 0201] loss: 3.1067\n",
      "[iteration 0301] loss: 2.8602\n",
      "[iteration 0401] loss: 2.7770\n",
      "[iteration 0501] loss: 2.6181\n",
      "[iteration 0601] loss: 2.4298\n",
      "[iteration 0701] loss: 2.0160\n",
      "[iteration 0801] loss: 1.7814\n",
      "[iteration 0901] loss: 1.5811\n"
     ]
    }
   ],
   "source": [
    "def train():\n",
    "    pyro.clear_param_store()\n",
    "    for j in range(num_iterations):\n",
    "        # calculate the loss and take a gradient step\n",
    "        loss = svi.step(x_data, y_data)\n",
    "        if j % 100 == 0:\n",
    "            print(\"[iteration %04d] loss: %.4f\" % (j + 1, loss / len(data)))\n",
    "\n",
    "train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "auto_loc tensor([-2.2026,  0.2936, -1.8873, -0.1607,  9.1753], requires_grad=True)\n",
      "auto_scale tensor([0.2285, 0.0954, 0.1376, 0.0600, 0.1042], grad_fn=<AddBackward0>)\n"
     ]
    }
   ],
   "source": [
    "for name, value in pyro.get_param_store().items():\n",
    "    print(name, pyro.param(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, instead of just point estimates, we now have uncertainty estimates (`auto_scale`) for our learned parameters.  Note that Autoguide packs the latent variables into a tensor, in this case, one entry per variable sampled in our model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Evaluation\n",
    "To evaluate our model, we'll generate some predictive samples and look at the posteriors. Since our variational distribution is fully parameterized, we can just run the lifted model forward.  We wrap the model with a `Delta` distribution in order to register the values with Pyro.  We then store the execution traces in the `posterior` object with `svi.run()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_marginal = lambda traces, sites:EmpiricalMarginal(traces, sites)._get_samples_and_weights()[0].detach().cpu().numpy()\n",
    "\n",
    "def summary(traces, sites):\n",
    "    marginal = get_marginal(traces, sites)\n",
    "    site_stats = {}\n",
    "    for i in range(marginal.shape[1]):\n",
    "        site_name = sites[i]\n",
    "        marginal_site = pd.DataFrame(marginal[:, i]).transpose()\n",
    "        describe = partial(pd.Series.describe, percentiles=[.05, 0.25, 0.5, 0.75, 0.95])\n",
    "        site_stats[site_name] = marginal_site.apply(describe, axis=1) \\\n",
    "            [[\"mean\", \"std\", \"5%\", \"25%\", \"50%\", \"75%\", \"95%\"]]\n",
    "    return site_stats\n",
    "\n",
    "def wrapped_model(x_data, y_data):\n",
    "    pyro.sample(\"prediction\", Delta(model(x_data, y_data)))\n",
    "\n",
    "posterior = svi.run(x_data, y_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# posterior predictive distribution we can get samples from\n",
    "trace_pred = TracePredictive(wrapped_model,\n",
    "                             posterior,\n",
    "                             num_samples=1000)\n",
    "post_pred = trace_pred.run(x_data, None)\n",
    "post_summary = summary(post_pred, sites= ['prediction', 'obs'])\n",
    "mu = post_summary[\"prediction\"]\n",
    "y = post_summary[\"obs\"]\n",
    "predictions = pd.DataFrame({\n",
    "    \"cont_africa\": x_data[:, 0],\n",
    "    \"rugged\": x_data[:, 1],\n",
    "    \"mu_mean\": mu[\"mean\"],\n",
    "    \"mu_perc_5\": mu[\"5%\"],\n",
    "    \"mu_perc_95\": mu[\"95%\"],\n",
    "    \"y_mean\": y[\"mean\"],\n",
    "    \"y_perc_5\": y[\"5%\"],\n",
    "    \"y_perc_95\": y[\"95%\"],\n",
    "    \"true_gdp\": y_data,\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'log GDP (2000)'),\n",
       " Text(0.5, 0, 'Terrain Ruggedness Index'),\n",
       " Text(0.5, 1.0, 'African Nations')]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6), sharey=True)\n",
    "african_nations = predictions[predictions[\"cont_africa\"] == 1]\n",
    "non_african_nations = predictions[predictions[\"cont_africa\"] == 0]\n",
    "african_nations = african_nations.sort_values(by=[\"rugged\"])\n",
    "non_african_nations = non_african_nations.sort_values(by=[\"rugged\"])\n",
    "fig.suptitle(\"Regression line 90% CI\", fontsize=16)\n",
    "ax[0].plot(non_african_nations[\"rugged\"],\n",
    "           non_african_nations[\"mu_mean\"])\n",
    "ax[0].fill_between(non_african_nations[\"rugged\"], \n",
    "                   non_african_nations[\"mu_perc_5\"],\n",
    "                   non_african_nations[\"mu_perc_95\"],\n",
    "                   alpha=0.5)\n",
    "ax[0].plot(non_african_nations[\"rugged\"], \n",
    "           non_african_nations[\"true_gdp\"],\n",
    "           \"o\")\n",
    "ax[0].set(xlabel=\"Terrain Ruggedness Index\",\n",
    "          ylabel=\"log GDP (2000)\",\n",
    "          title=\"Non African Nations\")\n",
    "idx = np.argsort(african_nations[\"rugged\"])\n",
    "ax[1].plot(african_nations[\"rugged\"], \n",
    "           african_nations[\"mu_mean\"])\n",
    "ax[1].fill_between(african_nations[\"rugged\"],\n",
    "                   african_nations[\"mu_perc_5\"],\n",
    "                   african_nations[\"mu_perc_95\"],\n",
    "                   alpha=0.5)\n",
    "ax[1].plot(african_nations[\"rugged\"], \n",
    "           african_nations[\"true_gdp\"],\n",
    "           \"o\")\n",
    "ax[1].set(xlabel=\"Terrain Ruggedness Index\",\n",
    "          ylabel=\"log GDP (2000)\",\n",
    "          title=\"African Nations\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above figure shows the uncertainty in our estimate of the regression line. Note that for lower values of ruggedness there are many more data points, and as such, lesser wiggle room for the line of best fit. This is reflected in the 90% CI around the mean. We can also see that most of the data points actually lie outside the 90% CI, and this is expected because we have not plotted the outcome variable which will be affected by `sigma`! Let us do so next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'log GDP (2000)'),\n",
       " Text(0.5, 0, 'Terrain Ruggedness Index'),\n",
       " Text(0.5, 1.0, 'African Nations')]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6), sharey=True)\n",
    "fig.suptitle(\"Posterior predictive distribution with 90% CI\", fontsize=16)\n",
    "ax[0].plot(non_african_nations[\"rugged\"], \n",
    "           non_african_nations[\"y_mean\"])\n",
    "ax[0].fill_between(non_african_nations[\"rugged\"], \n",
    "                   non_african_nations[\"y_perc_5\"],\n",
    "                   non_african_nations[\"y_perc_95\"],\n",
    "                   alpha=0.5)\n",
    "ax[0].plot(non_african_nations[\"rugged\"], \n",
    "           non_african_nations[\"true_gdp\"],\n",
    "           \"o\")\n",
    "ax[0].set(xlabel=\"Terrain Ruggedness Index\",\n",
    "          ylabel=\"log GDP (2000)\",\n",
    "          title=\"Non African Nations\")\n",
    "idx = np.argsort(african_nations[\"rugged\"])\n",
    "\n",
    "ax[1].plot(african_nations[\"rugged\"], \n",
    "           african_nations[\"y_mean\"])\n",
    "ax[1].fill_between(african_nations[\"rugged\"],\n",
    "                   african_nations[\"y_perc_5\"],\n",
    "                   african_nations[\"y_perc_95\"],\n",
    "                   alpha=0.5)\n",
    "ax[1].plot(african_nations[\"rugged\"], \n",
    "           african_nations[\"true_gdp\"],\n",
    "           \"o\")\n",
    "ax[1].set(xlabel=\"Terrain Ruggedness Index\",\n",
    "          ylabel=\"log GDP (2000)\",\n",
    "          title=\"African Nations\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that the outcome from our model and the 90% CI accounts for the majority of the data points that we observe in practice. It is usually a good idea to do such posterior predictive checks to see if our model gives valid predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0.98, 'Density of Slope : log(GDP) vs. Terrain Ruggedness')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we need to prepend `module$$$` to all parameters of nn.Modules since\n",
    "# that is how they are stored in the ParamStore\n",
    "weight = get_marginal(posterior, ['module$$$linear.weight']).squeeze(1).squeeze(1)\n",
    "factor = get_marginal(posterior, ['module$$$factor'])\n",
    "gamma_within_africa = weight[:, 1] + factor.squeeze(1)\n",
    "gamma_outside_africa = weight[:, 1]\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "sns.distplot(gamma_within_africa, kde_kws={\"label\": \"African nations\"},)\n",
    "sns.distplot(gamma_outside_africa, kde_kws={\"label\": \"Non-African nations\"})\n",
    "fig.suptitle(\"Density of Slope : log(GDP) vs. Terrain Ruggedness\", fontsize=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next section, we'll look at how to write guides for variational inference as well as compare the results with inference via HMC.\n",
    "\n",
    "See an example with a toy dataset on [Github](https://github.com/uber/pyro/blob/dev/examples/bayesian_regression.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References\n",
    "  1. McElreath, D., *Statistical Rethinking, Chapter 7*, 2016\n",
    "  2. Nunn, N. & Puga, D., *[Ruggedness: The blessing of bad geography in Africa\"](https://diegopuga.org/papers/rugged.pdf)*, Review of Economics and Statistics 94(1), Feb. 2012"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
